listitemfactory: Make the builder factory properly buildable

Turn the construct arguments into construct properties so that they can
be set from ui files.

listview: Add move keybindings

My god, these are a lot.

And my god, these are complicated to get right.

listview: Add gtk_list_view_get_position_at_y()

listitem: Add "listitem.select" action and keybindings for it

In fact, grab space with all modifiers to toggle selection of the
current item.

listview: Add a focus tracker

This ensures that the row with the input focus always stays available,
even when scrolled out of view.

listview: Implement (un)select all

Adds listitem.select-all and listitem.unselect-all actions and installs
the same keybindings as the treeview for those actions.

listview: Track focus movements and update selection

When focus moves via tab/arrow, we need to select the new item.

listview: Implement activation

- a GtkListview::activate signal
- a GtkListItem::activatable property
- activate list items on double clicks and <Enter> presses

treeexpander: Implement input support

This implements all the keybindings from GtkTreeView that can be
supported.

It does not implement expand-all, because supporting that means
causing the TreeListModel to emit lots of create_model vfuncs which in
turn would cause many items-changed signal which in turn would cause
many signal handlers to run which in turn would make "expand-all" very
reentrant, and I'm uneasy about supporting that.

For the mouse, just add a click gesture to the expander icon that toggles
expanded state.

listitem: Change focus handling

Focus in the listitem now works like this:
1. If any child can take focus, do not ever attempt
   to take focus.
2. Otherwise, if this item is selectable or activatable,
   allow focusing this widget.

This makes sure every item in a list is focusable for
activation and selection handling, but no useless widgets
get focused and moving focus is as fast as possible.

inspector: Make the recorder node list use a ListView

It's quite a bit faster now, but the code is also a bit more awkward.

Pain points:

- GtkTreeListModel cannot be created in UI files because it needs
  a CreateModelFunc.
  Using a signal for this doesn't work because autoexpand wants to
  expand the model before the signal handler is connected.

- The list item factory usage is still awkward. It's bearable here
  because the list items are very simple, but still.

inspector: Use a GtkTreeExpander in the object tree

inspector: Use a treeexpander in the recorder

demo: Add a GSettings tree demo

It is meant to look somewhat like dconf-editor when it is done.

So far, it's just a list.

Add GtkTreeExpander

This is a container widget that takes over all the duties of tree
expanding and collapsing.
It has to be a container so it can capture keybindings while focus is
inside the listitem.

So far, this widget does not allow interacting with it, but it shows the
expander arrow in its correct state.

Also, testlistview uses this widget now instead of implementing
expanding itself.

gridview: Actually do something

Implement measuring and allocating items - which makes the items appear
when drawing and allows interacting with the items.

However, the gridview still does not allow any user interaction
(including scrolling).

listview: Pass the CSS name of listitems to the manager

... instead of hardcoding "row".

gridview: Implement GtkOrientable

Again, this is just the skeleton, because the Gridview does nothing yet.

gridview: Add factory handling

Just copy the listview APIs.

Code still doesn't do anything with it.

listview: Expose GtkListItemFactory APIs

Due to the many different ways to set factories, it makes sense to
expose them as custom objects.

This makes the actual APIs for the list widgets simpler, because they
can just have a regular "factory" property.

As a convenience function, gtk_list_view_new_with_factory() was added
to make this whole approach easy to use from C.

gtk-demo: Add a rough start at a Weather demo

This demos a horizontal listview.

listview: Implement GtkOrientable

tests: Add a rough form of multiselection

Just store a "filechooser::selected" attribute in the GFileInfo if
the file is meant to be selected.

listview: Implement extending selections

Shift-clicking to extend selections now also works, imitating the
behavior of normal clicking and Windows Explorer (but not treeview):

1. We track the last selected item (normally, not via extend-clicking).

2. When shift-selecting, we modify the range from the last selected item
   to this item the same way we modify the regular item when not using
   shift:

2a. If Ctrl is not pressed, we select the range and unselect everything
    else.

2b. If Ctrl is pressed, we make the range have the same selection state
    as the last selected item:
    - If the last selected item is selected, select the range.
    - If the last selected item is not selected, unselect the range.

listview: Add list.scroll_to_item action

The action scrolls the given item into view.

Listitems activate this action when they gain focus.

testlistview: Load icons async

Speeds up loading by 4x, because out of view icons aren't loaded
anymore.

testlistview: Port to directory list

listitemfactory: Add a factory for ui files

Reuse <template> magic to initialize GtkListItems. This feels
amazingly hacky, but it also amazingly worked on the first try.

listitemfactory: Split implementation out

.. into gtkfunctionslistitemfactory.c

Now we can add a different implmenetation.

listitemfactory: vfuncify

No functional changes other than a new indirection.

listitemfactory: Sanitize APIs

Make sure the APIs follow a predictable path:

setup
  bind
    rebind/update (0-N times)
  unbind
teardown

This is the first step towards providing multiple different factories.

listview: Add gtk_list_view_set_show_separators()

Do the same thing that GtkListBox does in commit
0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44

listitemmanager: Add trackers

... and replace the anchor tracking with a tracker.

Trackers track an item through the list across changes and ensure that
this item (and potentially siblings before/after it) are always backed
by a GtkListItem and that if the item gets removed a replacement gets
chosen.

This is now used for tracking the anchor but can also be used to add
trackers for the cursor later.

listitemmanager: Simplify

Remove a bunch of API from the headers that isn't used anymore and then
refactor code to not call it anymore.

In particular, get rid of GtkListItemManagerChange and replace it with a
GHashTable.

gridview: Implement GtkScrollable

We can now scroll all the nothing we display.

We also clip it properly.

listitemmanager: Move list of listitems here

All the listview infrastructure moved with it, so the next step is
moving that back...

gridview: Add API for setting number of columns

The API isn't used yet.

gtk: Add a GtkGridView skeleton

listitem: Add a press gesture to select the item

This is implemented by using actions, which are a neat trick to get to
allow the ListItem to call functions on the ListView without actually
needing to be aware of it.

listview: Add initial support for displaying selections

listview: Reset listitems' CSS animations when rebinding

This way, newly displayed rows don't play an unselect animation (text
fading in) when they are unselected, but the row was previously used for
a selected item.

listview: Add selection properties to ListItem

This just brings the infrastructure into place, we're not using the
properties yet.

listview: Try to keep the list items in order when scrolling

Instead of just destroying all items and then recreating them (or even
hide()ing and then show()ing them again (or even even repositioning
them in the widget tree)), just try to reust them in the order they are.

This works surprisingly well when scrolling and most/all widgets
just moved.

listlistmodel: Add gtk_list_list_model_item_moved()

Use it to fix a case that just said g_warning ("oops").

Apparently I had forgotten the case where a container moved a child
in the widget tree.

listitemmanager: Switch from "insert_before" to "insert_after" argumnet

We reorder widgets start to end, so when reusing a list item, we
correctly know the previous sibling for that list item, but not the
next sibling yet. We just know the widget it should ultimately be in
front of.
So we can do a more correct guess of the list item's place in the widget
tree if we think about where to place an item like this.

Actually using this change will come in the next commit.

testlistview: Create widgets only once

Previously, we were recreating all widgets every time the list item was
rebound, which caused a lot of extra work every time we scrolled.

Now we keep the widgets around and only set their properties again when
the item changes.

testlistview: Show the row number

Always show the current row. This is mostly useful for debugging, not
for beauty.

listview: Only allocate necesary rows

This is the big one.

The listview only allocates 200 rows around the visible row now.
Everything else is kept in ListRow instances with row->widget == NULL.

For rows without a widget, we assign the median height of the child
widgets as the row's height and then do all calculations as if there
were widgets that had requested that height (like setting adjustment
values or reacting to adjustment value changes).

When the view is scrolled, we bind the 200 rows to the new visible area,
so that the part of the listview that can be seen is always allocated.

listview: Change anchor handling again

The anchor is now a tuple of { listitem, align }.

Using the actual list item allows keeping the anchor across changes
in position (ie when lists get resorted) while still being able to fall
back to positions (list items store their position) when an item gets
removed.

The align value is in the range [0..1] and defines where in the visible
area to do the alignment.
0.0 means to align the top of the row with the top of the visible area,
1.0 aligns the bottom of the widget with the visible area and 0.5 keeps
the center of the widget at the center of the visible area.
It works conceptually the same as percentages in CSS background-position
(where the background area and the background image's size are matched
the same way) or CSS transform-origin.

listview: Change how binding is done

We now don't let the functions create widgets for the item from the
listmodel, instead we hand out a GtkListItem for them to add a widget
to.

GtkListItems are created in advance and can only be filled in by the
binding code by gtk_container_add()ing a widget.
However, they are GObjects, so they can provide properties that the
binding code can make use of - either via notify signals or GBinding.

listitem: Add gtk_list_item_get_position()

Also refactor the whole list item management yet again.

Now, list item APIs doesn't have bind/unbind functions anymore, but only
property setters.

The item factory is the only one doing the binding.
As before, the item manager manages when items need to be bound.

tests: Make animating listview do random resorts

listview: Change change management

Add a GtkListItemManagerChange object that tracks all removed list
rows during an item-changed signal so they can be added back later.

listview: Make the listitemmanager stricter

Require that items created with the manager get destroyed via the
manager.

To that purpose, renamed create_list_item() to acquire_list_item() and
add a matching release_list_item() function.

This way, the manager can in the future keep track of all items and
cache information about them.

listview: Add GtkListItem

GtkListItem is a generic row widget that is supposed to replace
GtkListBoxRow and GtkFlowBoxChild.

listview: Add GtkListItemManager

It's all stubs for now, but here's the basic ideas about what
this object is supposed to do:

(1) It's supposed to be handling all the child GtkWidgets that are
    used by the listview, so that the listview can concern
    itself with how many items it needs and where to put them.
(2) It's meant to do the caching of widgets that are not (currently)
    used.
(3) It's meant to track items that remain in the model across
    items-changed emissions and just change position.
(2) It's code that can be shared between listview and potential
    other widgets like a GridView.

It's also free to assume that the number of items it's supposed to
manage doesn't grow too much, so it's free to use O(N) algorithms.

listview: Implement an anchor

The anchor selection is very basic: just anchor the top row.

That's vastly better than any other widget already though.

tests: Add a test for a permanently changing listview

This is mostly for dealing with proper anchoring and can be used to
check that things don't scroll or that selection and focus handling
properly works.

For comparison purposes, a ListBox is provided next to it.

listview: Implement GtkScrollable

Scrolling in a very basic form is also supported

listview: Make widget actually do something

The thing we're actually doing is create and maintain a widget for every
row. That's it.

Also add a testcase using this. The testcase quickly allocates too many
rows though and then becomes unresponsive though. You have been warned.

listview: Introduce GtkListItemFactory

Thisis the abstraction I intend to use for creating widgets and binding
them to the item out of the listview.

For now this is a very dumb wrapper around the functions that exist in
the API.

But it leaves the freedom to turn this into public API, make an
interface out of it and most of all write different implementations, in
particular one that uses GtkBuilder.

gtk: Add a GtkListView skeleton

builder: Add <binding> tag

The tag contains an expression that it then gtk_expression_bind()s to
the object it is contained in.

builder: Allow text content in <lookup>

  <lookup>foo</lookup>
is now short for
  <lookup>
    <constant>foo</constant>
  </lookup>
ie it looks up the object with the given name so it can then do a
property lookup with it.

This is the most common operation, so it's a nice shortcut.

builder: Allow <constant> without a type

A constant without a type is assumed to be an object. This is the most
common case and allows
  <constant>foo</constant>
without requiring updates to the type whenever the foo object changes.

builder: Make <lookup> type optional

If no type is set, use the type of the expression.

gtk-demo: Make fishbowl info text use bindings

It's a good demo for how bindings can format multiple properties into an
informative string with 1 line of code (and 5 lines of XML).

sorter: Add tests

Some basic tests for GtkSorter.

sortlistmodel: Make sort stable

The sort of the sortlistmodel is now stable with respect to the original
list model.

That means that if the sorter compares items as equal, the model
will make sure those items keep the order they were in in the original
model.

Or in other words: The model guarantees a total order based on the
item's position in the original model.

sortlistmodel: Redo the way we store the items

We need to keep this data around for changes in future commits where we
make the sorting stable.

An important part of the new data handling is that the unsorted list
needs to always be dealt with before the sorted list - upon creation we
rely on the unsorted iter and upon destruction, the sorted sequence
frees the entry leaving the unsorted sequence pointer invalid.

This change does not do any behavioral changes.

Redo sort list model with GtkSorter

Reshuffle the api to take full advantage
of GtkSorter. Update all callers.

Add GtkNumericSorter

This sorter compares numbers obtained from items
by evaluating an expression.

Add GtkMultiSorter

This is a sorter that tries multiple sorters in turn.

Add GtkStringSorter

This is a GtkSorter implementation collating strings

Add GtkCustomSorter

This is a GtkSorter implementation which uses a GCompareDataFunc.

Add GtkSorter

This is a helper object for sorting, similar to GtkFilter.

Add GtkOrdering

This is an enum that we're gonna use soon and it's worth introducing as a
separate commit.

The intention is to have meaningful names for return values in
comparison functions.

More expression tests

Test type mismatches, and the this pointer
during evaluation.

expression: Invalidate bindings before destroying them

Use a weak ref to invalidate bindings. Make sure that this happens
before creating any watches, so that notifies from the
watched expression about changes will not trigger set_property() calls
during dispose()/finalize().

Invalidating also ensures that the watches aren't removed, which can
trigger warnings if the watches are watching the object itself, and the
weak refs cannot be removed anymore.

expression: Add gtk_expression_bind()

Add a simple way to bind expressions to object properties. This is
essentially the thing to replace g_object_bind_property().

testsuite: Add expression tests

expression: Add the ability to watch an expression

builder: Add support for parsing expressions

filter: Add tests

Some basic tests for GtkFilter

Add GtkMultiFilter, GtkAnyFilter, GtkEveryFilter

GtkMultiFilter is the abstract base class for managing multiple child
filter.
GtkAnyFilter and GtkEveryFilter are the actual implementations.

filter: Add GtkStringFilter

Users provide a search filter and an expression that evaluates the items
to a string and then the filter goes and matches those strings to the
search term.

expression: Add GtkObjectExpression

Weak refs break cycles...

Add GtkExpression

GtkExpressions allow looking up values from objects.

There are a few simple expressions, but the main one is the closure
expression that just calls a user-provided closure.

filterlistmodel: Rewrite to use GtkFilter

tests: Remove testtreemodel test

testlistview does everything this test does.

Add GtkCustomFilter

Add GtkFilter

Add GtkDirectoryList

Adds a new listmodel called GtkDirectoryList that lists the children of
a GFile as GFileInfos.

This is supposed to be used by the filechooser.

eventcontrollermotion: Remove mode argument

It's not used and nobody has documented how it's meant to work anyway.

Merge branch 'fix-pango-deps' into 'master'

Fix inconsistencies in our pango deps

See merge request GNOME/gtk!1989

Merge branch 'matthiasc/for-master' into 'master'

Some listview preparations

See merge request GNOME/gtk!1988

Fix inconsistencies in our pango deps

We were applying the pango version requirements inconsistently,
leading to different pango variables being taking from system
pango vs the subproject at times. Thankfully, meson detects
this and complains, so we can fix it.

Merge branch 'fix-gesture-leak' into 'master'

gesture: Don't leak target widgets

Closes #2801

See merge request GNOME/gtk!1986

widget: Add gtk_widget_get_size()

A little bit of convenience.

wayland: Remove function declaration for nonexisting function